原理簡介(1)

對抗生成網路(Generative Adversarial Networks，GAN)是近年深度學習領域最重要的突破之一，首先由Ian J. Goodfellow於2014年所提出的研究Generative Adversarial Networks描述其實現過程。

F15_1

他的任務目標是「模擬」產生新的物件(圖像、文字等)，但又要足夠的「真」。

– 從數學上來說，就是形成一個預測函數，而該函數的目標是做隨機亂數與新的物件的映射：

F15_2

要產生這樣的預測函數，我們不能簡單的給定一堆「隨機數」與「真實圖像」，直接讓網路學習他們之間的關係，原因在於這個映射關係仍然是有意義的，舉例來說第一個特徵可能是描述人臉的膚色，第二個特徵描述人臉的寬度等，我們不可能預先知道所有圖像的特徵，因此必須透過其他方法進行訓練。

原理簡介(2)

對抗生成網路巧妙的避開了剛剛講的上述問題，他首先使用一個生成網路(AI-1)，任務目標是透過「隨機數」預測「假圖像」，再使用一個對抗網路(AI-2)，任務目標是分辨「假圖像」與「真圖像」。

F15_3

透過兩個網路的互相競賽，最終生成網路為了能夠騙過辨別網路，就有能力產生出以假亂真的圖片。
一個模型包含兩個網路看起來並不是特別難的事情，之前的自編碼器已經示範過了。

– 但其實這兩個網路是不可能合在一起one-stage訓練的，你看得出為什麼嗎?

實現一個手寫數字產生器(1)

讓我們利用MNIST的資料，在開始前請先下載我們在第10課中用的train_data.csv、sub_train_data.csv以及test_data.csv。
我們先來編寫Iterator，記住我們的目標總共要輸出「雜訊」、「真實圖像」、「標籤」共三種，這裡我們直接修改之前第六課的手寫數字辨識的Iterator：

library(mxnet)

my_iterator_func <- setRefClass("Custom_Iter",
                                fields = c("iter", "data.csv", "data.shape", "batch.size"),
                                contains = "Rcpp_MXArrayDataIter",
                                methods = list(
                                  initialize = function(iter, data.csv, data.shape, batch.size){
                                    csv_iter <- mx.io.CSVIter(data.csv = data.csv, data.shape = data.shape, batch.size = batch.size)
                                    .self$iter <- csv_iter
                                    .self
                                  },
                                  value = function(){
                                    val <- as.array(.self$iter$value()$data)
                                    val.x <- val[-1,]
                                    batch_size <- ncol(val.x)
                                    val.x <- val.x / 255 # Important        
                                    dim(val.x) <- c(28, 28, 1, batch_size)
                                    rand <- rnorm(batch_size * 10, mean = 0, sd = 1)
                                    rand <- array(rand, dim = c(1, 1, 10, batch_size))
                                    rand <- mx.nd.array(rand)
                                    val.x <- mx.nd.array(val.x)
                                    val.y.0 <- array(rep(0, batch_size), dim = c(1, 1, 1, batch_size))
                                    val.y.0 <- mx.nd.array(val.y.0)
                                    val.y.1 <- array(rep(1, batch_size), dim = c(1, 1, 1, batch_size))
                                    val.y.1 <- mx.nd.array(val.y.1)
                                    list(noise = rand, img = val.x, label.0 = val.y.0, label.1 = val.y.1)
                                  },
                                  iter.next = function(){
                                    .self$iter$iter.next()
                                  },
                                  reset = function(){
                                    .self$iter$reset()
                                  },
                                  finalize=function(){
                                  }
                                )
)

my_iter <- my_iterator_func(iter = NULL,  data.csv = 'data/train_data.csv', data.shape = 785, batch.size = 32)

實現一個手寫數字產生器(2)

接著定義Model architecture，這個部分就有滿多複雜且有趣的地方了。

– 首先定義Generator：

gen_data <- mx.symbol.Variable('data')

gen_deconv1 <- mx.symbol.Deconvolution(data = gen_data, kernel = c(4, 4), stride = c(2, 2), num_filter = 256, name = 'gen_deconv1')
gen_bn1 <- mx.symbol.BatchNorm(data = gen_deconv1, fix_gamma = TRUE, name = 'gen_bn1')
gen_relu1 <- mx.symbol.Activation(data = gen_bn1, act_type = "relu", name = 'gen_relu1')

gen_deconv2 <- mx.symbol.Deconvolution(data = gen_relu1, kernel = c(3, 3), stride = c(2, 2), pad = c(1, 1), num_filter = 128, name = 'gen_deconv2')
gen_bn2 <- mx.symbol.BatchNorm(data = gen_deconv2, fix_gamma = TRUE, name = 'gen_bn2')
gen_relu2 <- mx.symbol.Activation(data = gen_bn2, act_type = "relu", name = 'gen_relu2')

gen_deconv3 <- mx.symbol.Deconvolution(data = gen_relu2, kernel = c(4, 4), stride = c(2, 2), pad = c(1, 1), num_filter = 64, name = 'gen_deconv3')
gen_bn3 <- mx.symbol.BatchNorm(data = gen_deconv3, fix_gamma = TRUE, name = 'gen_bn3')
gen_relu3 <- mx.symbol.Activation(data = gen_bn3, act_type = "relu", name = 'gen_relu3')

gen_deconv4 <- mx.symbol.Deconvolution(data = gen_relu3, kernel = c(4, 4), stride = c(2, 2), pad = c(1, 1), num_filter = 1, name = 'gen_deconv4')
gen_pred <- mx.symbol.Activation(data = gen_deconv4, act_type = "sigmoid", name = 'gen_pred')

– 接著定義Discriminator：

dis_img <- mx.symbol.Variable('img')
dis_label <- mx.symbol.Variable('label')

dis_conv1 <- mx.symbol.Convolution(data = dis_img, kernel = c(3, 3), num_filter = 24, no.bias = TRUE, name = 'dis_conv1')
dis_bn1 <- mx.symbol.BatchNorm(data = dis_conv1, fix_gamma = TRUE, name = 'dis_bn1')
dis_relu1 <- mx.symbol.LeakyReLU(data = dis_bn1, act_type = "leaky", slope = 0.25, name = "dis_relu1")
dis_pool1 <- mx.symbol.Pooling(data = dis_relu1, pool_type = "avg", kernel = c(2, 2), stride = c(2, 2), name = 'dis_pool1')

dis_conv2 <- mx.symbol.Convolution(data = dis_pool1, kernel = c(3, 3), stride = c(2, 2), num_filter = 32, no.bias = TRUE, name = 'dis_conv2')
dis_bn2 <- mx.symbol.BatchNorm(data = dis_conv2, fix_gamma = TRUE, name = 'dis_bn2')
dis_relu2 <- mx.symbol.LeakyReLU(data = dis_bn2, act_type = "leaky", slope = 0.25, name = "dis_relu2")

dis_conv3 <- mx.symbol.Convolution(data = dis_relu2, kernel = c(3, 3), num_filter = 64, no.bias = TRUE, name = 'dis_conv3')
dis_bn3 <- mx.symbol.BatchNorm(data = dis_conv3, fix_gamma = TRUE, name = 'dis_bn3')
dis_relu3 <- mx.symbol.LeakyReLU(data = dis_bn3, act_type = "leaky", slope = 0.25, name = "dis_relu3")

dis_conv4 <- mx.symbol.Convolution(data = dis_relu3, kernel = c(4, 4), num_filter = 64, no.bias = TRUE, name = 'dis_conv4')
dis_bn4 <- mx.symbol.BatchNorm(data = dis_conv4, fix_gamma = TRUE, name = 'dis_bn4')
dis_relu4 <- mx.symbol.LeakyReLU(data = dis_bn4, act_type = "leaky", slope = 0.25, name = "dis_relu4")

dis_conv5 <- mx.symbol.Convolution(data = dis_relu4, kernel = c(1, 1), num_filter = 1, name = 'dis_conv5')
dis_pred <- mx.symbol.sigmoid(data = dis_conv5, name = 'dis_pred')

– 我們再來定義Loss function，只有Discriminator有Loss function：

eps <- 1e-8
ce_loss_pos <-  mx.symbol.broadcast_mul(mx.symbol.log(dis_pred + eps), dis_label)
ce_loss_neg <-  mx.symbol.broadcast_mul(mx.symbol.log(1 - dis_pred + eps), 1 - dis_label)
ce_loss_mean <- 0 - mx.symbol.mean(ce_loss_pos + ce_loss_neg)
ce_loss <- mx.symbol.MakeLoss(ce_loss_mean, name = 'ce_loss')

實現一個手寫數字產生器(3)

接著在Optimizer的部份我們選用Adam，而Generator和Discriminator必須使用不同的Optimizer：

gen_optimizer <- mx.opt.create(name = "adam", learning.rate = 2e-4, beta1 = 0.5, beta2 = 0.999, epsilon = 1e-08, wd = 0)
dis_optimizer <- mx.opt.create(name = "adam", learning.rate = 2e-4, beta1 = 0.5, beta2 = 0.999, epsilon = 1e-08, wd = 0)

由於訓練過程至少必須分成兩階段進行，所以我們必須自己編寫Executor：

gen_executor <- mx.simple.bind(symbol = gen_pred,
                               data = c(1, 1, 10, 32),
                               ctx = mx.cpu(), grad.req = "write")

dis_executor <- mx.simple.bind(symbol = ce_loss,
                               img = c(28, 28, 1, 32), label = c(1, 1, 1, 32),
                               ctx = mx.cpu(), grad.req = "write")

初始化權重參數並將他更新至Executor內：

# Initial parameters

mx.set.seed(0)

gen_arg <- mxnet:::mx.model.init.params(symbol = gen_pred,
                                        input.shape = list(data = c(1, 1, 10, 32)),
                                        output.shape = NULL,
                                        initializer = mxnet:::mx.init.uniform(0.01),
                                        ctx = mx.cpu())

dis_arg <- mxnet:::mx.model.init.params(symbol = ce_loss,
                                        input.shape = list(img = c(28, 28, 1, 32), label = c(1, 1, 1, 32)),
                                        output.shape = NULL,
                                        initializer = mxnet:::mx.init.uniform(0.01),
                                        ctx = mx.cpu())

# Update parameters

mx.exec.update.arg.arrays(gen_executor, gen_arg$arg.params, match.name = TRUE)
mx.exec.update.aux.arrays(gen_executor, gen_arg$aux.params, match.name = TRUE)
mx.exec.update.arg.arrays(dis_executor, dis_arg$arg.params, match.name = TRUE)
mx.exec.update.aux.arrays(dis_executor, dis_arg$aux.params, match.name = TRUE)

根據參數定義Updater：

gen_updater <- mx.opt.get.updater(optimizer = gen_optimizer, weights = gen_executor$ref.arg.arrays)
dis_updater <- mx.opt.get.updater(optimizer = dis_optimizer, weights = dis_executor$ref.arg.arrays)

實現一個手寫數字產生器(4)

可以開始訓練了，但在我們開始迴圈之前先慢慢執行整個過程，要特別注意Label與資料在每個階段對應的關係：

# Generate data

my_iter$reset()
my_iter$iter.next()

## [1] TRUE

my_values <- my_iter$value()

# Generator (forward)
    
mx.exec.update.arg.arrays(gen_executor, arg.arrays = list(data = my_values[['noise']]), match.name = TRUE)
mx.exec.forward(gen_executor, is.train = TRUE)
gen_pred_output <- gen_executor$ref.outputs[[1]]

# Discriminator (fake)
    
mx.exec.update.arg.arrays(dis_executor, arg.arrays = list(img = gen_pred_output, label = my_values[['label.0']]), match.name = TRUE)
mx.exec.forward(dis_executor, is.train = TRUE)
mx.exec.backward(dis_executor)
dis_update_args <- dis_updater(weight = dis_executor$ref.arg.arrays, grad = dis_executor$ref.grad.arrays)
mx.exec.update.arg.arrays(dis_executor, dis_update_args, skip.null = TRUE)

# Discriminator (real)
    
mx.exec.update.arg.arrays(dis_executor, arg.arrays = list(img = my_values[['img']], label = my_values[['label.1']]), match.name = TRUE)
mx.exec.forward(dis_executor, is.train = TRUE)
mx.exec.backward(dis_executor)
dis_update_args <- dis_updater(weight = dis_executor$ref.arg.arrays, grad = dis_executor$ref.grad.arrays)
mx.exec.update.arg.arrays(dis_executor, dis_update_args, skip.null = TRUE)

# Generator (backward)

mx.exec.update.arg.arrays(dis_executor, arg.arrays = list(img = gen_pred_output, label = my_values[['label.1']]), match.name = TRUE)
mx.exec.forward(dis_executor, is.train = TRUE)
mx.exec.backward(dis_executor)
img_grads <- dis_executor$ref.grad.arrays[['img']]
mx.exec.backward(gen_executor, out_grads = img_grads)
gen_update_args <- gen_updater(weight = gen_executor$ref.arg.arrays, grad = gen_executor$ref.grad.arrays)
mx.exec.update.arg.arrays(gen_executor, gen_update_args, skip.null = TRUE)

我們看一下初始階段Generator所產生的圖像吧：

library(imager)

par(mfrow = c(3, 3), mar = c(0.1, 0.1, 0.1, 0.1))

for (i in 1:9) {
  img <- as.array(gen_pred_output)[,,,i]
  plot(NA, xlim = 0:1, ylim = 0:1, xaxt = "n", yaxt = "n", bty = "n")
  rasterImage(as.raster(t(img)), -0.04, -0.04, 1.04, 1.04, interpolate = FALSE)
}

實現一個手寫數字產生器(5)

讓我們把這一整包弄成迴圈吧，另外我們還想記錄整個訓練的過程，讓我們先定義一下：

set.seed(0)
n.epoch <- 20
logger <- list(gen_loss = NULL, dis_real_loss = NULL, dis_fake_loss = NULL)

開始大規模的訓練(這個要跑一陣子，但你可以觀察一下圖像的變化)：

for (j in 1:n.epoch) {
  
  current_batch <- 0
  my_iter$reset()
  
  while (my_iter$iter.next()) {
    
    my_values <- my_iter$value()
    
    # Generator (forward)
    
    mx.exec.update.arg.arrays(gen_executor, arg.arrays = list(data = my_values[['noise']]), match.name = TRUE)
    mx.exec.forward(gen_executor, is.train = TRUE)
    gen_pred_output <- gen_executor$ref.outputs[[1]]
    
    # Discriminator (fake)
    
    mx.exec.update.arg.arrays(dis_executor, arg.arrays = list(img = gen_pred_output, label = my_values[['label.0']]), match.name = TRUE)
    mx.exec.forward(dis_executor, is.train = TRUE)
    mx.exec.backward(dis_executor)
    dis_update_args <- dis_updater(weight = dis_executor$ref.arg.arrays, grad = dis_executor$ref.grad.arrays)
    mx.exec.update.arg.arrays(dis_executor, dis_update_args, skip.null = TRUE)
    
    logger$dis_fake_loss <- c(logger$dis_fake_loss, as.array(dis_executor$ref.outputs[[1]]))
    
    # Discriminator (real)
    
    mx.exec.update.arg.arrays(dis_executor, arg.arrays = list(img = my_values[['img']], label = my_values[['label.1']]), match.name = TRUE)
    mx.exec.forward(dis_executor, is.train = TRUE)
    mx.exec.backward(dis_executor)
    dis_update_args <- dis_updater(weight = dis_executor$ref.arg.arrays, grad = dis_executor$ref.grad.arrays)
    mx.exec.update.arg.arrays(dis_executor, dis_update_args, skip.null = TRUE)
    
    logger$dis_real_loss <- c(logger$dis_real_loss, as.array(dis_executor$ref.outputs[[1]]))
    
    # Generator (backward)
    
    mx.exec.update.arg.arrays(dis_executor, arg.arrays = list(img = gen_pred_output, label = my_values[['label.1']]), match.name = TRUE)
    mx.exec.forward(dis_executor, is.train = TRUE)
    mx.exec.backward(dis_executor)
    img_grads <- dis_executor$ref.grad.arrays[['img']]
    mx.exec.backward(gen_executor, out_grads = img_grads)
    gen_update_args <- gen_updater(weight = gen_executor$ref.arg.arrays, grad = gen_executor$ref.grad.arrays)
    mx.exec.update.arg.arrays(gen_executor, gen_update_args, skip.null = TRUE)
    
    logger$gen_loss <- c(logger$gen_loss, as.array(dis_executor$ref.outputs[[1]]))
    
    if (current_batch %% 100 == 0) {
      
      # Show current images
      
      par(mfrow = c(3, 3), mar = c(0.1, 0.1, 0.1, 0.1))
      for (i in 1:9) {
        img <- as.array(gen_pred_output)[,,,i]
        plot(NA, xlim = 0:1, ylim = 0:1, xaxt = "n", yaxt = "n", bty = "n")
        rasterImage(as.raster(t(img)), -0.04, -0.04, 1.04, 1.04, interpolate = FALSE)
      }
      
      # Show loss
      
      message('Epoch [', j, '] Batch [', current_batch, '] Generator-loss = ', formatC(tail(logger$gen_loss, 1), digits = 5, format = 'f'))
      message('Epoch [', j, '] Batch [', current_batch, '] Discriminator-loss (real) = ', formatC(tail(logger$dis_real_loss, 1), digits = 5, format = 'f'))
      message('Epoch [', j, '] Batch [', current_batch, '] Discriminator-loss (fake) = ', formatC(tail(logger$dis_fake_loss, 1), digits = 5, format = 'f'))
      
    }
    
    current_batch <- current_batch + 1
    
  }
  
  pdf(paste0('result/epoch_', j, '.pdf'), height = 6, width = 6)
  par(mfrow = c(3, 3), mar = c(0.1, 0.1, 0.1, 0.1))
  for (i in 1:9) {
    img <- as.array(gen_pred_output)[,,,i]
    plot(NA, xlim = 0:1, ylim = 0:1, xaxt = "n", yaxt = "n", bty = "n")
    rasterImage(as.raster(t(img)), -0.04, -0.04, 1.04, 1.04, interpolate = FALSE)
  }
  dev.off()
  
  gen_model <- list()
  gen_model$symbol <- gen_pred
  gen_model$arg.params <- gen_executor$ref.arg.arrays[-1]
  gen_model$aux.params <- gen_executor$ref.aux.arrays
  class(gen_model) <- "MXFeedForwardModel"
  
  dis_model <- list()
  dis_model$symbol <- dis_pred
  dis_model$arg.params <- dis_executor$ref.arg.arrays[-1]
  dis_model$aux.params <- dis_executor$ref.aux.arrays
  class(dis_model) <- "MXFeedForwardModel"
  
  mx.model.save(model = gen_model, prefix = 'model/gen_v1', iteration = j)
  mx.model.save(model = dis_model, prefix = 'model/dis_v1', iteration = j)
  
}

$F15_5$

實現一個手寫數字產生器(6)

這20個Epoch結束時Generator所畫出的圖，你有沒有覺得真的越來越像了?

如果你想要整個訓練最終所獲得的Generator，你可以分別下載gen_v1-0000.params以及gen_v1-symbol.json，並且用亂數考驗他：

gen_model <- mx.model.load('model/gen_v1', 0)

set.seed(1)

noise_input <- array(rnorm(100), dim = c(1, 1, 10, 10))
pred_img <- predict(gen_model, noise_input)

par(mfrow = c(2, 5), mar = c(0.1, 0.1, 0.1, 0.1))

for (i in 1:10) {
  img <- pred_img[,,,i]
  plot(NA, xlim = 0:1, ylim = 0:1, xaxt = "n", yaxt = "n", bty = "n")
  rasterImage(as.raster(t(img)), -0.04, -0.04, 1.04, 1.04, interpolate = FALSE)
}

從亂數產生手寫數字，我們曾經在第10課的自編碼器中有實現類似的過程，他的邏輯是圖像經過壓縮後一定會保留最重要的特徵，而最終每個特徵都相對到了一定的意義，讓我們複習一下當時的結果：

使用對抗生成網路所產生的生成器是不是好非常多呢?

實現一個手寫數字產生器(7)

這是一個很特殊的任務，讓我們觀察一下他的loss軌跡：

range_logger <- logger %>% unlist %>% range

plot(logger$gen_loss, type = 'l', col = 'red', lwd = 0.5, ylim = range_logger, xlab = 'Batch', ylab = 'loss')
lines(1:length(logger$dis_real_loss), logger$dis_real_loss, col = 'blue', lwd = 0.5)
lines(1:length(logger$dis_fake_loss), logger$dis_fake_loss, col = 'darkgreen', lwd = 0.5)
legend('topright', c('Gen', 'Real', 'Fake'), col = c('red', 'blue', 'darkgreen'), lwd = 1)

由於Generator與Discriminator彼此優化的目標完全相反，所以在訓練的時候Loss其實並不能給我們甚麼資訊(我們很難提前停止)，我們僅能從Loss上了解Generator與Discriminator在各時間點的競賽狀態。

實現一個手寫數字產生器(8)

更有趣的地方在，我們可以透過生成器看看初始向量慢慢改變與圖像的對應關係：

set.seed(1)

input.1 <- rnorm(10)

noise_input <- array(input.1, dim = c(1, 1, 10, 10))
for (i in 2:10) {
  noise_input[,,,i] <- noise_input[,,,i-1] + 0.1
}

pred_img <- predict(gen_model, noise_input)

par(mfrow = c(2, 5), mar = c(0.1, 0.1, 0.1, 0.1))

for (i in 1:10) {
  img <- pred_img[,,,i]
  plot(NA, xlim = 0:1, ylim = 0:1, xaxt = "n", yaxt = "n", bty = "n")
  rasterImage(as.raster(t(img)), -0.04, -0.04, 1.04, 1.04, interpolate = FALSE)
}

這代表著生成器確實學習到一個映射函數讓初始向量對應到數字，你可以觀察到他從7變化到9的過程就代表著初始向量確實代表某些訊息。

練習1：實現第一個GAN並且調整超參數

重複一次上述的過程，完成你的第一個對抗生成網路吧！(你可以在這裡下載完整語法)

– 另外，你應該有注意到我們剛剛的在訓練對抗生成網路時，在許多地方的超參數設定似乎並不是使用常用的值：

我們使用了Adam進行優化，但卻採用了0.0002的學習率以及0.5的beta1，另外為什麼不能改成SGD?
在Generator的部分我們使用了ReLU作非線性轉換，而Discriminator中卻使用LeakyReLU，能統一嗎?
在Generator的部分最終我們使用了Sigmoid輸出，當然像素是介於0至1的值，但這樣不是會造成梯度消失，能把這個限制打開嗎?
訓練Discriminator的過程中我們把fake與real分開訓練，是不是覺得怪怪的?

為了回答這個問題，你們必須修正小部分的程式碼再進行一次實驗，你會應該會發現對抗生成網路並不是一個非常穩健的模型，超參數只要稍微調整一下生成效果就會不好，上面的問題在程式碼的修正上由簡單到難，試著選擇一個感興趣的實驗進行吧！

練習1答案(1)

我們以實現第一個(這應該也是最奇怪的調整)問題為例，所有程式碼都不需要修正，只需要調整Optimizer的參數：

gen_optimizer <- mx.opt.create(name = "adam", learning.rate = 1e-3, beta1 = 0.9, beta2 = 0.999, epsilon = 1e-08, wd = 0)
dis_optimizer <- mx.opt.create(name = "adam", learning.rate = 1e-3, beta1 = 0.9, beta2 = 0.999, epsilon = 1e-08, wd = 0)

你會發現後果非常嚴重，下面是用這組參數訓練的結果：

你覺得為什麼會這樣呢?

練習1答案(2)

事實上，對抗生成網路的理論看起來合理且容易實現，但在真實運用時非常難調整正確的參數，有許多研究(Alec Radford et al., 2015; Soumith Chintala et al., 2016)提出一系列重要的訓練須知，讓我們來看看幾個比較重要的事，而這些其實就是我們練習1的問題：

Generator的最終輸出是tanh、sigmoid等bounds normalization function
一個mini-batch中必須確保只有假樣本或者真樣本
避免稀疏梯度(ReLU、Max Pooling)，原則上在Discriminator中使用slope為0.2的Leaky ReLU，在Generator中可以使用ReLU
使用Adam訓練模型，但調整為0.0002的學習率以及0.5的beta1

還有一些小技巧：

反轉訓練標籤(fake = 1; real = 0)
使用噪音標籤(fake = 0.9-1.0; real = 0.0-0.1)訓練Discriminator

利用判別器進行轉移特徵學習(1)

如果你還對之前的自編碼器有印象的話，你會發現對抗生成網路跟他非常的像，差別只在自編碼器是「壓縮→還原」，而對抗生成網路是「生成→判別」，他們的順序相反。

– 因此，自編碼器的壓縮器能夠拿來做轉移特徵學習，那當然我們也能試試使用判別器來做轉移特徵學習。

這是我們500份小資料的Iterator：

my_iterator_func2 <- setRefClass("Custom_Iter2",
                                fields = c("iter", "data.csv", "data.shape", "batch.size"),
                                contains = "Rcpp_MXArrayDataIter",
                                methods = list(
                                  initialize = function(iter, data.csv, data.shape, batch.size){
                                    csv_iter <- mx.io.CSVIter(data.csv = data.csv, data.shape = data.shape, batch.size = batch.size)
                                    .self$iter <- csv_iter
                                    .self
                                  },
                                  value = function(){
                                    val <- as.array(.self$iter$value()$data)
                                    val.x <- val[-1,]
                                    dim(val.x) <- c(28, 28, 1, ncol(val.x))
                                    val.x <- val.x/255
                                    val.x <- mx.nd.array(val.x)
                                    val.y <- t(model.matrix(~ -1 + factor(val[1,], levels = 0:9)))
                                    val.y <- array(val.y, dim = c(10, dim(val.x)[4]))
                                    val.y <- mx.nd.array(val.y)
                                    list(data=val.x, label=val.y)
                                  },
                                  iter.next = function(){
                                    .self$iter$iter.next()
                                  },
                                  reset = function(){
                                    .self$iter$reset()
                                  },
                                  finalize=function(){
                                  }
                                )
)

my_iter2 <- my_iterator_func2(iter = NULL,  data.csv = 'data/sub_train_data.csv', data.shape = 785, batch.size = 20)

利用判別器進行轉移特徵學習(2)

為了讓實驗具有可比性，我們使用同樣的結構進行比較：

data <- mx.symbol.Variable('data')

dis_conv1 <- mx.symbol.Convolution(data = data, kernel = c(3, 3), num_filter = 24, no.bias = TRUE, name = 'dis_conv1')
dis_bn1 <- mx.symbol.BatchNorm(data = dis_conv1, fix_gamma = TRUE, name = 'dis_bn1')
dis_relu1 <- mx.symbol.LeakyReLU(data = dis_bn1, act_type = "leaky", slope = 0.25, name = "dis_relu1")
dis_pool1 <- mx.symbol.Pooling(data = dis_relu1, pool_type = "avg", kernel = c(2, 2), stride = c(2, 2), name = 'dis_pool1')

dis_conv2 <- mx.symbol.Convolution(data = dis_pool1, kernel = c(3, 3), stride = c(2, 2), num_filter = 32, no.bias = TRUE, name = 'dis_conv2')
dis_bn2 <- mx.symbol.BatchNorm(data = dis_conv2, fix_gamma = TRUE, name = 'dis_bn2')
dis_relu2 <- mx.symbol.LeakyReLU(data = dis_bn2, act_type = "leaky", slope = 0.25, name = "dis_relu2")

dis_conv3 <- mx.symbol.Convolution(data = dis_relu2, kernel = c(3, 3), num_filter = 64, no.bias = TRUE, name = 'dis_conv3')
dis_bn3 <- mx.symbol.BatchNorm(data = dis_conv3, fix_gamma = TRUE, name = 'dis_bn3')
dis_relu3 <- mx.symbol.LeakyReLU(data = dis_bn3, act_type = "leaky", slope = 0.25, name = "dis_relu3")

dis_conv4 <- mx.symbol.Convolution(data = dis_relu3, kernel = c(4, 4), num_filter = 64, no.bias = TRUE, name = 'dis_conv4')
dis_bn4 <- mx.symbol.BatchNorm(data = dis_conv4, fix_gamma = TRUE, name = 'dis_bn4')
dis_relu4 <- mx.symbol.LeakyReLU(data = dis_bn4, act_type = "leaky", slope = 0.25, name = "dis_relu4")

fc1 <- mx.symbol.FullyConnected(data = dis_relu4, num.hidden = 10, name = 'fc1')
softmax <- mx.symbol.softmax(data = fc1, axis = 1, name = 'softmax')

label <- mx.symbol.Variable(name = 'label')

eps <- 1e-8
m_log <- 0 - mx.symbol.mean(mx.symbol.broadcast_mul(mx.symbol.log(softmax + eps), label))
m_logloss <- mx.symbol.MakeLoss(m_log, name = 'm_logloss')

定義一下Optimizer：

my_optimizer <- mx.opt.create(name = "adam", learning.rate = 0.001, beta1 = 0.9, beta2 = 0.999, wd = 1e-4)

我們這裡使用內建的函數「mx.model.FeedForward.create」進行運算：

my.eval.metric.loss <- mx.metric.custom(
  name = "mlog-loss", 
  function(real, pred) {
    return(pred)
  }
)

mx.set.seed(0)

model.1 <- mx.model.FeedForward.create(symbol = m_logloss, X = my_iter2, optimizer = my_optimizer,
                                       eval.metric = my.eval.metric.loss,
                                       array.batch.size = 20, ctx = mx.cpu(), num.round = 100)

利用判別器進行轉移特徵學習(3)

讓我們讀取測試資料集來看看模型的準確度

library(data.table)

Test.DAT = fread("data/test_data.csv", data.table = FALSE)

Test.X = t(Test.DAT[,-1])
dim(Test.X) = c(28, 28, 1, ncol(Test.X))
Test.X = Test.X/255
Test.Y = Test.DAT[,1]

接著我們可以把「model.1」中的symbol改成我們要的，接著就能做測試集資料的預測了：

model.1$symbol <- softmax

predict_Y <- predict(model.1, Test.X)
confusion_table <- table(max.col(t(predict_Y)), Test.Y)
cat("Testing accuracy rate =", sum(diag(confusion_table))/sum(confusion_table))

## Testing accuracy rate = 0.928631

print(confusion_table)

##     Test.Y
##         0    1    2    3    4    5    6    7    8    9
##   1  1619    0    8    7    7    8   27    6   12    7
##   2     0 1823    8    3   14    8    5   16   22    7
##   3     2    8 1559   17    3    4    6   26   15    3
##   4     2    2   31 1660    0   99    1   24   24   15
##   5     1    3    3    0 1433    1   13   24    3   77
##   6     2    0    3   18    0 1380   67    0   20    6
##   7     8    1    3    0   10   10 1534    1   10    0
##   8     1    6   21    9    4   11    0 1567    3   39
##   9    21    7   18   19   17   17    6    8 1544    6
##   10    7    1    2    9  118   13    2   81   22 1482

在這個Model architecture之下Baseline的準確度約92.9%，讓我們使用轉移特徵學習看看。

利用判別器進行轉移特徵學習(4)

現在讓我們把「dis_model」的值用於轉移特徵學習，試試看準確性是否會提升?

– 如果你想要獲得一個訓練好的Discriminator，你可以分別下載dis_v1-0000.params以及dis_v1-symbol.json。

dis_model <- mx.model.load('model/dis_v1', 0)

mx.set.seed(0)
new_arg <- mxnet:::mx.model.init.params(symbol = m_logloss,
                                        input.shape = list(data = c(28, 28, 1, 7), label = c(10, 7)),
                                        output.shape = NULL,
                                        initializer = mxnet:::mx.init.uniform(0.01),
                                        ctx = mx.cpu())

for (k in 1:12) {
  new_arg$arg.params[[k]] <- dis_model$arg.params[[k]]
}

model.2 <- mx.model.FeedForward.create(symbol = m_logloss, X = my_iter2, optimizer = my_optimizer,
                                       eval.metric = my.eval.metric.loss,
                                       arg.params = new_arg$arg.params,
                                       array.batch.size = 20, ctx = mx.cpu(), num.round = 100)

再使用model.2做進一步預測：

model.2$symbol <- softmax

predict_Y <- predict(model.2, Test.X)
confusion_table <- table(max.col(t(predict_Y)), Test.Y)
cat("Testing accuracy rate =", sum(diag(confusion_table))/sum(confusion_table))

## Testing accuracy rate = 0.9335119

print(confusion_table)

##     Test.Y
##         0    1    2    3    4    5    6    7    8    9
##   1  1635    0    5    3    5   19   16   14   11   10
##   2     0 1820   10    2   10    7    7   19   13   10
##   3     2    9 1565   26    3    4    5   18   23    3
##   4     2    0   23 1644    0   41    0   22   27   26
##   5     1    4    6    0 1447    1   22   20    3   84
##   6     1    0    1   23    0 1436   50    3   28    9
##   7     5    2    5    1   12   17 1544    1    7    0
##   8     3    4   18    7    7    5    0 1585    0   18
##   9    12   12   21   25   19   14    8   10 1539   14
##   10    2    0    2   11  103    7    9   61   24 1468

準確性提升到約93.4%，可見對抗生成網路跟自編碼器這種無監督學習都能降低訓練模型消耗的資源。

條件式對抗生成網路(1)

學會基本的圖像生成技術之後，我們下一個關心的是我們能不能指定一個數字，讓Generator生成特定的數字?

– 要做到這件事情並不是太難的事情，只要我們在網路的Input增加條件標籤，如此一來就能做到！而這種網路的名稱叫做條件式對抗生成網路(Conditional Generative Adversarial Nets, CGAN)。

我們來定義一下我們的Model architecture，首先定義Generator：

gen_data <- mx.symbol.Variable('data')
gen_digit <- mx.symbol.Variable('digit')

gen_concat <- mx.symbol.concat(data = list(gen_data, gen_digit), num.args = 2, dim = 1, name = "gen_concat")

gen_deconv1 <- mx.symbol.Deconvolution(data = gen_concat, kernel = c(4, 4), stride = c(2, 2), num_filter = 256, name = 'gen_deconv1')
gen_bn1 <- mx.symbol.BatchNorm(data = gen_deconv1, fix_gamma = TRUE, name = 'gen_bn1')
gen_relu1 <- mx.symbol.Activation(data = gen_bn1, act_type = "relu", name = 'gen_relu1')

gen_deconv2 <- mx.symbol.Deconvolution(data = gen_relu1, kernel = c(3, 3), stride = c(2, 2), pad = c(1, 1), num_filter = 128, name = 'gen_deconv2')
gen_bn2 <- mx.symbol.BatchNorm(data = gen_deconv2, fix_gamma = TRUE, name = 'gen_bn2')
gen_relu2 <- mx.symbol.Activation(data = gen_bn2, act_type = "relu", name = 'gen_relu2')

gen_deconv3 <- mx.symbol.Deconvolution(data = gen_relu2, kernel = c(4, 4), stride = c(2, 2), pad = c(1, 1), num_filter = 64, name = 'gen_deconv3')
gen_bn3 <- mx.symbol.BatchNorm(data = gen_deconv3, fix_gamma = TRUE, name = 'gen_bn3')
gen_relu3 <- mx.symbol.Activation(data = gen_bn3, act_type = "relu", name = 'gen_relu3')

gen_deconv4 <- mx.symbol.Deconvolution(data = gen_relu3, kernel = c(4, 4), stride = c(2, 2), pad = c(1, 1), num_filter = 1, name = 'gen_deconv4')
gen_pred <- mx.symbol.Activation(data = gen_deconv4, act_type = "sigmoid", name = 'gen_pred')

你應該有注意到其實改變非常的少！

條件式對抗生成網路(2)

接著定義Discriminator，這裡要特別注意到整合「dis_img」與「dis_digit」的技巧，我們是將本來28×28×1的圖像輸入，轉換成28×28×10的輸入，用這種方式告訴Discriminator目前是哪一種數字：

dis_img <- mx.symbol.Variable('img')
dis_digit <- mx.symbol.Variable("digit")
dis_label <- mx.symbol.Variable('label')

dis_concat <- mx.symbol.broadcast_mul(lhs = dis_img, rhs = dis_digit, name = 'dis_concat')

dis_conv1 <- mx.symbol.Convolution(data = dis_concat, kernel = c(3, 3), num_filter = 24, no.bias = TRUE, name = 'dis_conv1')
dis_bn1 <- mx.symbol.BatchNorm(data = dis_conv1, fix_gamma = TRUE, name = 'dis_bn1')
dis_relu1 <- mx.symbol.LeakyReLU(data = dis_bn1, act_type = "leaky", slope = 0.2, name = "dis_relu1")
dis_pool1 <- mx.symbol.Pooling(data = dis_relu1, pool_type = "avg", kernel = c(2, 2), stride = c(2, 2), name = 'dis_pool1')

dis_conv2 <- mx.symbol.Convolution(data = dis_pool1, kernel = c(3, 3), stride = c(2, 2), num_filter = 32, no.bias = TRUE, name = 'dis_conv2')
dis_bn2 <- mx.symbol.BatchNorm(data = dis_conv2, fix_gamma = TRUE, name = 'dis_bn2')
dis_relu2 <- mx.symbol.LeakyReLU(data = dis_bn2, act_type = "leaky", slope = 0.2, name = "dis_relu2")

dis_conv3 <- mx.symbol.Convolution(data = dis_relu2, kernel = c(3, 3), num_filter = 64, no.bias = TRUE, name = 'dis_conv3')
dis_bn3 <- mx.symbol.BatchNorm(data = dis_conv3, fix_gamma = TRUE, name = 'dis_bn3')
dis_relu3 <- mx.symbol.LeakyReLU(data = dis_bn3, act_type = "leaky", slope = 0.2, name = "dis_relu3")

dis_conv4 <- mx.symbol.Convolution(data = dis_relu3, kernel = c(4, 4), num_filter = 64, no.bias = TRUE, name = 'dis_conv4')
dis_bn4 <- mx.symbol.BatchNorm(data = dis_conv4, fix_gamma = TRUE, name = 'dis_bn4')
dis_relu4 <- mx.symbol.LeakyReLU(data = dis_bn4, act_type = "leaky", slope = 0.2, name = "dis_relu4")

dis_conv5 <- mx.symbol.Convolution(data = dis_relu4, kernel = c(1, 1), num_filter = 1, name = 'dis_conv5')
dis_pred <- mx.symbol.sigmoid(data = dis_conv5, name = 'dis_pred')

– 我們再來定義Loss function：

eps <- 1e-8
ce_loss_pos <-  mx.symbol.broadcast_mul(mx.symbol.log(dis_pred + eps), dis_label)
ce_loss_neg <-  mx.symbol.broadcast_mul(mx.symbol.log(1 - dis_pred + eps), 1 - dis_label)
ce_loss_mean <- 0 - mx.symbol.mean(ce_loss_pos + ce_loss_neg)
ce_loss <- mx.symbol.MakeLoss(ce_loss_mean, name = 'ce_loss')

條件式對抗生成網路(3)

在Iterator的部分，我們將使用所有之前所提到的小技巧，包含了反轉+噪音標籤：

my_iterator_func <- setRefClass("Custom_Iter",
                                fields = c("iter", "data.csv", "data.shape", "batch.size"),
                                contains = "Rcpp_MXArrayDataIter",
                                methods = list(
                                  initialize = function(iter, data.csv, data.shape, batch.size){
                                    csv_iter <- mx.io.CSVIter(data.csv = data.csv, data.shape = data.shape, batch.size = batch.size)
                                    .self$iter <- csv_iter
                                    .self
                                  },
                                  value = function(){
                                    val <- as.array(.self$iter$value()$data)
                                    val.x <- val[-1,]
                                    batch_size <- ncol(val.x)
                                    val.x <- val.x / 255 # Important        
                                    dim(val.x) <- c(28, 28, 1, batch_size)
                                    val.x <- mx.nd.array(val.x)
                                    
                                    digit.real <- mx.nd.array(val[1,])
                                    digit.real <- mx.nd.one.hot(indices = digit.real, depth = 10)
                                    digit.real <- mx.nd.reshape(data = digit.real, shape = c(1, 1, -1, batch_size))
                                      
                                    digit.fake <- mx.nd.array(sample(0:9, size = batch_size, replace = TRUE))
                                    digit.fake <- mx.nd.one.hot(indices = digit.fake, depth = 10)
                                    digit.fake <- mx.nd.reshape(data = digit.fake, shape = c(1, 1, -1, batch_size))

                                    rand <- rnorm(batch_size * 10, mean = 0, sd = 1)
                                    rand <- array(rand, dim = c(1, 1, 10, batch_size))
                                    rand <- mx.nd.array(rand)
                                    
                                    label.real <- array(runif(10, 0, 0.1), dim = c(1, 1, 1, batch_size))
                                    label.real <- mx.nd.array(label.real)
                                    label.fake <- array(runif(10, 0.9, 1), dim = c(1, 1, 1, batch_size))
                                    label.fake <- mx.nd.array(label.fake)
                                    label.gen <- array(rep(0, 10), dim = c(1, 1, 1, batch_size))
                                    label.gen <- mx.nd.array(label.gen)
                                    
                                    list(noise = rand, img = val.x, digit.fake = digit.fake, digit.real = digit.real, label.fake = label.fake, label.real = label.real, label.gen = label.gen)
                                  },
                                  iter.next = function(){
                                    .self$iter$iter.next()
                                  },
                                  reset = function(){
                                    .self$iter$reset()
                                  },
                                  finalize=function(){
                                  }
                                )
)

my_iter <- my_iterator_func(iter = NULL,  data.csv = 'data/train_data.csv', data.shape = 785, batch.size = 32)

條件式對抗生成網路(4)

接著在Optimizer的部份我們選用Adam(跟之前一樣)：

gen_optimizer <- mx.opt.create(name = "adam", learning.rate = 2e-4, beta1 = 0.5, beta2 = 0.999, epsilon = 1e-08, wd = 0)
dis_optimizer <- mx.opt.create(name = "adam", learning.rate = 2e-4, beta1 = 0.5, beta2 = 0.999, epsilon = 1e-08, wd = 0)

這是Generator跟Discriminator的Executor：

gen_executor <- mx.simple.bind(symbol = gen_pred,
                               data = c(1, 1, 10, 32), digit = c(1, 1, 10, 32),
                               ctx = mx.cpu(), grad.req = "write")

dis_executor <- mx.simple.bind(symbol = ce_loss,
                               img = c(28, 28, 1, 32), digit = c(1, 1, 10, 32), label = c(1, 1, 1, 32),
                               ctx = mx.cpu(), grad.req = "write")

初始化權重參數並將他更新至Executor內：

# Initial parameters

mx.set.seed(0)

gen_arg <- mxnet:::mx.model.init.params(symbol = gen_pred,
                                        input.shape = list(data = c(1, 1, 10, 32), digit = c(1, 1, 10, 32)),
                                        output.shape = NULL,
                                        initializer = mxnet:::mx.init.uniform(0.01),
                                        ctx = mx.cpu())

dis_arg <- mxnet:::mx.model.init.params(symbol = ce_loss,
                                        input.shape = list(img = c(28, 28, 1, 32), digit = c(1, 1, 10, 32), label = c(1, 1, 1, 32)),
                                        output.shape = NULL,
                                        initializer = mxnet:::mx.init.uniform(0.01),
                                        ctx = mx.cpu())

# Update parameters

mx.exec.update.arg.arrays(gen_executor, gen_arg$arg.params, match.name = TRUE)
mx.exec.update.aux.arrays(gen_executor, gen_arg$aux.params, match.name = TRUE)
mx.exec.update.arg.arrays(dis_executor, dis_arg$arg.params, match.name = TRUE)
mx.exec.update.aux.arrays(dis_executor, dis_arg$aux.params, match.name = TRUE)

根據參數定義Updater：

gen_updater <- mx.opt.get.updater(optimizer = gen_optimizer, weights = gen_executor$ref.arg.arrays)
dis_updater <- mx.opt.get.updater(optimizer = dis_optimizer, weights = dis_executor$ref.arg.arrays)

條件式對抗生成網路(5)

訓練的過程跟前面的完全一樣，首先定義代數與logger：

set.seed(0)
n.epoch <- 20
logger <- list(gen_loss = NULL, dis_real_loss = NULL, dis_fake_loss = NULL)

再開始大規模的訓練：

for (j in 1:n.epoch) {
  
  current_batch <- 0
  my_iter$reset()
  
  while (my_iter$iter.next()) {
    
    my_values <- my_iter$value()
    
    # Generator (forward)
    
    mx.exec.update.arg.arrays(gen_executor, arg.arrays = list(data = my_values[['noise']], digit = my_values[['digit.fake']]), match.name = TRUE)
    mx.exec.forward(gen_executor, is.train = TRUE)
    gen_pred_output <- gen_executor$ref.outputs[[1]]
    
    # Discriminator (fake)
    
    mx.exec.update.arg.arrays(dis_executor, arg.arrays = list(img = gen_pred_output, digit = my_values[['digit.fake']], label = my_values[['label.fake']]), match.name = TRUE)
    mx.exec.forward(dis_executor, is.train = TRUE)
    mx.exec.backward(dis_executor)
    dis_update_args <- dis_updater(weight = dis_executor$ref.arg.arrays, grad = dis_executor$ref.grad.arrays)
    mx.exec.update.arg.arrays(dis_executor, dis_update_args, skip.null = TRUE)
    
    logger$dis_fake_loss <- c(logger$dis_fake_loss, as.array(dis_executor$ref.outputs[[1]]))
    
    # Discriminator (real)
    
    mx.exec.update.arg.arrays(dis_executor, arg.arrays = list(img = my_values[['img']], digit = my_values[['digit.real']], label = my_values[['label.real']]), match.name = TRUE)
    mx.exec.forward(dis_executor, is.train = TRUE)
    mx.exec.backward(dis_executor)
    dis_update_args <- dis_updater(weight = dis_executor$ref.arg.arrays, grad = dis_executor$ref.grad.arrays)
    mx.exec.update.arg.arrays(dis_executor, dis_update_args, skip.null = TRUE)
    
    logger$dis_real_loss <- c(logger$dis_real_loss, as.array(dis_executor$ref.outputs[[1]]))
    
    # Generator (backward)
    
    mx.exec.update.arg.arrays(dis_executor, arg.arrays = list(img = gen_pred_output, digit = my_values[['digit.fake']], label = my_values[['label.gen']]), match.name = TRUE)
    mx.exec.forward(dis_executor, is.train = TRUE)
    mx.exec.backward(dis_executor)
    img_grads <- dis_executor$ref.grad.arrays[['img']]
    mx.exec.backward(gen_executor, out_grads = img_grads)
    gen_update_args <- gen_updater(weight = gen_executor$ref.arg.arrays, grad = gen_executor$ref.grad.arrays)
    mx.exec.update.arg.arrays(gen_executor, gen_update_args, skip.null = TRUE)
    
    logger$gen_loss <- c(logger$gen_loss, as.array(dis_executor$ref.outputs[[1]]))
    
    if (current_batch %% 100 == 0) {
      
      # Show current images
      
      par(mfrow = c(3, 3), mar = c(0.1, 0.1, 0.1, 0.1))
      for (i in 1:9) {
        img <- as.array(gen_pred_output)[,,,i]
        plot(NA, xlim = 0:1, ylim = 0:1, xaxt = "n", yaxt = "n", bty = "n")
        rasterImage(as.raster(t(img)), -0.04, -0.04, 1.04, 1.04, interpolate = FALSE)
      }
      
      # Show loss
      
      message('Epoch [', j, '] Batch [', current_batch, '] Generator-loss = ', formatC(tail(logger$gen_loss, 1), digits = 5, format = 'f'))
      message('Epoch [', j, '] Batch [', current_batch, '] Discriminator-loss (real) = ', formatC(tail(logger$dis_real_loss, 1), digits = 5, format = 'f'))
      message('Epoch [', j, '] Batch [', current_batch, '] Discriminator-loss (fake) = ', formatC(tail(logger$dis_fake_loss, 1), digits = 5, format = 'f'))
      
    }
    
    current_batch <- current_batch + 1
    
  }
  
  pdf(paste0('result/epoch_', j, '.pdf'), height = 6, width = 6)
  par(mfrow = c(3, 3), mar = c(0.1, 0.1, 0.1, 0.1))
  for (i in 1:9) {
    img <- as.array(gen_pred_output)[,,,i]
    plot(NA, xlim = 0:1, ylim = 0:1, xaxt = "n", yaxt = "n", bty = "n")
    rasterImage(as.raster(t(img)), -0.04, -0.04, 1.04, 1.04, interpolate = FALSE)
  }
  dev.off()
  
  gen_model <- list()
  gen_model$symbol <- gen_pred
  gen_model$arg.params <- gen_executor$ref.arg.arrays[-c(1:2)]
  gen_model$aux.params <- gen_executor$ref.aux.arrays
  class(gen_model) <- "MXFeedForwardModel"
  
  dis_model <- list()
  dis_model$symbol <- dis_pred
  dis_model$arg.params <- dis_executor$ref.arg.arrays[-c(1:2)]
  dis_model$aux.params <- dis_executor$ref.aux.arrays
  class(dis_model) <- "MXFeedForwardModel"
  
  mx.model.save(model = gen_model, prefix = 'model/cgen_v1', iteration = j)
  mx.model.save(model = dis_model, prefix = 'model/cdis_v1', iteration = j)
  
}

練習2：使用CGAN進行指定數字的生成任務

再讓我們重複一次上述的過程，完成一個條件式對抗生成網路吧！(你可以在這裡下載完整語法)

– 在訓練的過程中，你應該能慢慢發現數字越來越貼近真實的狀況！

現在我們雖然獲得了Generator的參數，但這個模型由於有多重輸入，我們不能再使用MxNet內建的函數「predict」直接預測，所以現在請你編寫一個函數讓我們能指定輸出數字，並在函數內部隨機產生亂數生成該數字圖像！

– 如果你的電腦訓練速度太慢，你可以先下載cgen_v1-0000.params以及cgen_v1-symbol.json得到Generator的參數。

gen_model <- mx.model.load('model/cgen_v1', 0)

練習2答案

這是客製化的預測函數：

my_predict <- function (model, digits = 0:9) {
  
  batch_size <- length(digits)
  
  gen_executor <- mx.simple.bind(symbol = model$symbol,
                                 data = c(1, 1, 10, batch_size), digit = c(1, 1, 10, batch_size),
                                 ctx = mx.cpu())
  
  mx.exec.update.arg.arrays(gen_executor, model$arg.params, match.name = TRUE)
  mx.exec.update.aux.arrays(gen_executor, model$aux.params, match.name = TRUE)
  
  noise_array <- rnorm(batch_size * 10, mean = 0, sd = 1)
  noise_array <- array(noise_array, dim = c(1, 1, 10, batch_size))
  noise_array <- mx.nd.array(noise_array)
  
  digit_array <- mx.nd.array(digits)
  digit_array <- mx.nd.one.hot(indices = digit_array, depth = 10)
  digit_array <- mx.nd.reshape(data = digit_array, shape = c(1, 1, -1, batch_size))
  
  mx.exec.update.arg.arrays(gen_executor, arg.arrays = list(data = noise_array, digit = digit_array), match.name = TRUE)
  mx.exec.forward(gen_executor, is.train = FALSE)
  gen_pred_output <- gen_executor$ref.outputs[[1]]
  
  return(as.array(gen_pred_output))
  
}

讓我們看看預測結果，請他匯出0至9：

pred_img <- my_predict(model = gen_model, digits = 0:9)

par(mfrow = c(2, 5), mar = c(0.1, 0.1, 0.1, 0.1))

for (i in 1:10) {
  img <- pred_img[,,,i]
  plot(NA, xlim = 0:1, ylim = 0:1, xaxt = "n", yaxt = "n", bty = "n")
  rasterImage(as.raster(t(img)), -0.04, -0.04, 1.04, 1.04, interpolate = FALSE)
}

你可以多試試幾次(因為有隨機向量，數字圖像會變換)，或指定不同的數字輸入測試一下這個函數。

利用假資料輔助模型訓練(1)

有能力產生特定數字的圖像後，我們有個大膽的想法，有沒有可能在訓練分類器時使用假資料增加樣本，從而讓模型準確度提升?

– 讓我們來嘗試一下吧，但要注意的是剛剛的生成模型實際上使用了25200個標籤資料做訓練，所以我們要重建Baseline模型，而這是Iterator的部分：

my_iter2 <- my_iterator_func2(iter = NULL,  data.csv = 'data/train_data.csv', data.shape = 785, batch.size = 20)

我們使用原始對抗生成網路中的Discriminator結構進行分析：

data <- mx.symbol.Variable('data')

dis_conv1 <- mx.symbol.Convolution(data = data, kernel = c(3, 3), num_filter = 24, no.bias = TRUE, name = 'dis_conv1')
dis_bn1 <- mx.symbol.BatchNorm(data = dis_conv1, fix_gamma = TRUE, name = 'dis_bn1')
dis_relu1 <- mx.symbol.LeakyReLU(data = dis_bn1, act_type = "leaky", slope = 0.25, name = "dis_relu1")
dis_pool1 <- mx.symbol.Pooling(data = dis_relu1, pool_type = "avg", kernel = c(2, 2), stride = c(2, 2), name = 'dis_pool1')

dis_conv2 <- mx.symbol.Convolution(data = dis_pool1, kernel = c(3, 3), stride = c(2, 2), num_filter = 32, no.bias = TRUE, name = 'dis_conv2')
dis_bn2 <- mx.symbol.BatchNorm(data = dis_conv2, fix_gamma = TRUE, name = 'dis_bn2')
dis_relu2 <- mx.symbol.LeakyReLU(data = dis_bn2, act_type = "leaky", slope = 0.25, name = "dis_relu2")

dis_conv3 <- mx.symbol.Convolution(data = dis_relu2, kernel = c(3, 3), num_filter = 64, no.bias = TRUE, name = 'dis_conv3')
dis_bn3 <- mx.symbol.BatchNorm(data = dis_conv3, fix_gamma = TRUE, name = 'dis_bn3')
dis_relu3 <- mx.symbol.LeakyReLU(data = dis_bn3, act_type = "leaky", slope = 0.25, name = "dis_relu3")

dis_conv4 <- mx.symbol.Convolution(data = dis_relu3, kernel = c(4, 4), num_filter = 64, no.bias = TRUE, name = 'dis_conv4')
dis_bn4 <- mx.symbol.BatchNorm(data = dis_conv4, fix_gamma = TRUE, name = 'dis_bn4')
dis_relu4 <- mx.symbol.LeakyReLU(data = dis_bn4, act_type = "leaky", slope = 0.25, name = "dis_relu4")

fc1 <- mx.symbol.FullyConnected(data = dis_relu4, num.hidden = 10, name = 'fc1')
softmax <- mx.symbol.softmax(data = fc1, axis = 1, name = 'softmax')

label <- mx.symbol.Variable(name = 'label')

eps <- 1e-8
m_log <- 0 - mx.symbol.mean(mx.symbol.broadcast_mul(mx.symbol.log(softmax + eps), label))
m_logloss <- mx.symbol.MakeLoss(m_log, name = 'm_logloss')

定義一下Optimizer：

my_optimizer <- mx.opt.create(name = "adam", learning.rate = 0.001, beta1 = 0.9, beta2 = 0.999, wd = 1e-4)

利用假資料輔助模型訓練(2)

我們已經證實了使用轉移特徵學習進行權重初始化會有更佳的效果，讓我們直接用上原始GAN的Discriminator權重：

dis_model <- mx.model.load('model/dis_v1', 0)

mx.set.seed(0)
new_arg <- mxnet:::mx.model.init.params(symbol = m_logloss,
                                        input.shape = list(data = c(28, 28, 1, 7), label = c(10, 7)),
                                        output.shape = NULL,
                                        initializer = mxnet:::mx.init.uniform(0.01),
                                        ctx = mx.cpu())

for (k in 1:12) {
  new_arg$arg.params[[k]] <- dis_model$arg.params[[k]]
}

model.1 <- mx.model.FeedForward.create(symbol = m_logloss, X = my_iter2, optimizer = my_optimizer,
                                       eval.metric = my.eval.metric.loss,
                                       arg.params = new_arg$arg.params,
                                       array.batch.size = 20, ctx = mx.cpu(), num.round = 20)

讓我們直接使用測試資料集來做預測(第17頁有檔案讀取的程式碼)，我們同樣只要把「model.1」中的symbol改成我們要的，接著就能直接預測了：

model.1$symbol <- softmax

predict_Y <- predict(model.1, Test.X)
confusion_table <- table(max.col(t(predict_Y)), Test.Y)
cat("Testing accuracy rate =", sum(diag(confusion_table))/sum(confusion_table))

## Testing accuracy rate = 0.9856548

print(confusion_table)

##     Test.Y
##         0    1    2    3    4    5    6    7    8    9
##   1  1652    0    2    0    4    2    8    1    1    7
##   2     0 1839    4    2    1    0    0    8    2    1
##   3     0    4 1641    7    1    1    2   15    5    0
##   4     0    1    1 1713    0    8    1    4    3    6
##   5     0    3    1    0 1581    0    1    7    1   10
##   6     1    0    0   10    0 1530    1    0    6    5
##   7     2    0    0    1    2    4 1645    0    6    0
##   8     0    0    2    3    3    0    0 1708    0   10
##   9     6    3    5    4    2    4    3    4 1648    1
##   10    2    1    0    2   12    2    0    6    3 1602

在這個Model architecture之下Baseline的準確度約98.6%，讓我們同時使用假資料試試看！

利用假資料輔助模型訓練(3)

我們必須重新定義我們的Iterator，在這個Iterator中，我們有一半的機率使用假資料：

gen_model <- mx.model.load('model/cgen_v1', 0)

my_predict <- function (model, digits = 0:9) {
  
  batch_size <- length(digits)
  
  gen_executor <- mx.simple.bind(symbol = model$symbol,
                                 data = c(1, 1, 10, batch_size), digit = c(1, 1, 10, batch_size),
                                 ctx = mx.cpu())
  
  mx.exec.update.arg.arrays(gen_executor, model$arg.params, match.name = TRUE)
  mx.exec.update.aux.arrays(gen_executor, model$aux.params, match.name = TRUE)
  
  noise_array <- rnorm(batch_size * 10, mean = 0, sd = 1)
  noise_array <- array(noise_array, dim = c(1, 1, 10, batch_size))
  noise_array <- mx.nd.array(noise_array)
  
  digit_array <- mx.nd.array(digits)
  digit_array <- mx.nd.one.hot(indices = digit_array, depth = 10)
  digit_array <- mx.nd.reshape(data = digit_array, shape = c(1, 1, -1, batch_size))
  
  mx.exec.update.arg.arrays(gen_executor, arg.arrays = list(data = noise_array, digit = digit_array), match.name = TRUE)
  mx.exec.forward(gen_executor, is.train = FALSE)
  gen_pred_output <- gen_executor$ref.outputs[[1]]
  
  return(as.array(gen_pred_output))
  
}

my_iterator_func3 <- setRefClass("Custom_Iter3",
                                fields = c("iter", "data.csv", "data.shape", "batch.size"),
                                contains = "Rcpp_MXArrayDataIter",
                                methods = list(
                                  initialize = function(iter, data.csv, data.shape, batch.size){
                                    csv_iter <- mx.io.CSVIter(data.csv = data.csv, data.shape = data.shape, batch.size = batch.size)
                                    .self$iter <- csv_iter
                                    .self
                                  },
                                  value = function(){
                                    val <- as.array(.self$iter$value()$data)
                                    val.y <- val[1,]
                                    if (sample(0:1, 1) == 1) {
                                      val.x <- my_predict(model = gen_model, digits = val.y)
                                    } else {
                                      val.x <- val[-1,]
                                      dim(val.x) <- c(28, 28, 1, ncol(val.x))
                                      val.x <- val.x/255
                                    }
                                    val.x <- mx.nd.array(val.x)
                                    val.y <- t(model.matrix(~ -1 + factor(val.y, levels = 0:9)))
                                    val.y <- array(val.y, dim = c(10, dim(val.x)[4]))
                                    val.y <- mx.nd.array(val.y)
                                    list(data=val.x, label=val.y)
                                  },
                                  iter.next = function(){
                                    .self$iter$iter.next()
                                  },
                                  reset = function(){
                                    .self$iter$reset()
                                  },
                                  finalize=function(){
                                  }
                                )
)

my_iter3 <- my_iterator_func3(iter = NULL,  data.csv = 'data/train_data.csv', data.shape = 785, batch.size = 20)

利用假資料輔助模型訓練(4)

後面的過程就完全一樣了，我們使用完全一樣的Model architecture與Optimizer：

dis_model <- mx.model.load('model/dis_v1', 0)

mx.set.seed(0)
new_arg <- mxnet:::mx.model.init.params(symbol = m_logloss,
                                        input.shape = list(data = c(28, 28, 1, 7), label = c(10, 7)),
                                        output.shape = NULL,
                                        initializer = mxnet:::mx.init.uniform(0.01),
                                        ctx = mx.cpu())

for (k in 1:12) {
  new_arg$arg.params[[k]] <- dis_model$arg.params[[k]]
}

model.2 <- mx.model.FeedForward.create(symbol = m_logloss, X = my_iter3, optimizer = my_optimizer,
                                       eval.metric = my.eval.metric.loss,
                                       arg.params = new_arg$arg.params,
                                       array.batch.size = 20, ctx = mx.cpu(), num.round = 20)

使用測試資料集來做預測：

model.2$symbol <- softmax

predict_Y <- predict(model.2, Test.X)
confusion_table <- table(max.col(t(predict_Y)), Test.Y)
cat("Testing accuracy rate =", sum(diag(confusion_table))/sum(confusion_table))

## Testing accuracy rate = 0.9817857

print(confusion_table)

##     Test.Y
##         0    1    2    3    4    5    6    7    8    9
##   1  1656    0    6    1    5    3   17    2   13   10
##   2     0 1840    5    3    5    1    0    5    3    1
##   3     1    3 1627    3    0    1    2    8    9    2
##   4     0    0   10 1705    0    4    1    3    3    3
##   5     0    0    0    0 1576    0    2    4    3   14
##   6     3    3    2   20    0 1534    7    0   12    8
##   7     0    1    0    0    4    6 1631    0   12    1
##   8     1    3    4    4    2    1    0 1725    1   17
##   9     0    1    2    3    2    0    1    2 1616    2
##   10    2    0    0    3   12    1    0    4    3 1584

使用一半的假資料準確度是98.2%，可見訓練對抗生成網路產生假資料來訓練效果可能不會太好。

– 當然，也許你會說是我們的生成模型還有訓練空間，但這個實驗也大致能說明假資料其實對訓練監督模型的幫助非常有限。

結語

今天的課程帶大家實現了一個經典的對抗生成網路，以及稍微進化版的條件式對抗生成網路，儘管想法很簡單，你應該有注意到他的程式編寫起來卻非常複雜，並且對抗生成網路的訓練非常難調整參數，所以其實要訓練出好的生成器其實也不簡單。

– 另外，如果你想要利用對抗生成網路的無監督特性協助監督模型的訓練，你會發現目前為止效果其實跟自編碼器差別不大，所以他並不是這麼簡單的就能輕易應用。

然而，就像Yann LeCun所說得話：”Generative Adversarial Network is the most interesting idea in the last ten years in machine learning.”，對抗生成網路可以說是人工智慧領域最重要的突破之一，並且無監督的特性值得好好應用。

– 目前的神經網路大多需要極大量的標註樣本才能訓練得好，但人類的學習過程中似乎並不需要如此大量的標註資訊，因此如何利用無監督模型輔助模型訓練是目前研究的重要熱點。

在這些簡單模型的基礎之下，近年在對抗生成網路中最重要的突破莫過於循環對抗生成網路(Cycle GAN)，我們下週將會試著展示他的威力，而Facebook AI團隊更是利用了這個模型成功實現了「無平行語料」的翻譯任務，並且取得了比利用「少量平行語料」訓練的模型更好的成績！(Guillaume Lample et al., 2017)

F15_8

讓我們透過學習這些強大的模型，展望未來的人工智慧發展！

對抗生成網路概述